home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_08_09 / 8n09083a < prev    next >
Text File  |  1990-05-30  |  13KB  |  584 lines
  1. /*
  2.      +--------------------------------------------------------------+
  3.      |    @(#) bfs_cmon.c   v1.0   90/04/02                           |
  4.      |                                                              |
  5.      |  Copyright (C) 1990, StonyBrook Technologies, Inc.,          |
  6.      |  All Rights Reserved.                                        |
  7.      |                                                              |
  8.      |  This Module contains Proprietary Information of             |
  9.      |  StonyBrook Technologies, Inc. and should be treated         |
  10.      |  as Confidential.                                            |
  11.      |                                                              |
  12.      +--------------------------------------------------------------+
  13.  
  14.      bfs_cmon.c - this is a client server daemon.
  15.  
  16. */
  17.  
  18. #include <stdio.h>
  19. #include <sys/fcntl.h>
  20. #include <sys/types.h>
  21. #include <sys/stat.h>
  22. #include <errno.h>
  23. #include <sys/signal.h>
  24. #include <varargs.h>
  25. #include <eicon/x25.h>
  26. #include "bfs.h"
  27.  
  28. static int running = 1;  /* running bit - can be modified on SIGINT */
  29.  
  30. char    cname[16];        /* client name */
  31. char    laddr[16];          /* client addr */
  32. int     cfifo;              /* client fifo */
  33.  
  34. int    c_lcb_cnt = 0;      /* line cntl blk count */
  35. C_LCB    c_lcb[MAX_C_LCB];   /* line cntl blk       */
  36.  
  37. C_FCB   c_fcb[MAX_C_FCB];   /* apl fifo cntl blk   */
  38. C_SCB   c_scb[MAX_C_SCB];   /* session cntl blk    */
  39.  
  40. /* x.25 call parameter data */
  41. struct x25parm x25_parms = { 0, "", 0, "", "" };
  42.  
  43. /* debug stuff */
  44. int cmon_io;
  45. char cmon_buf[132];
  46. int debug_flag = 0;
  47.  
  48.  
  49. signal_trap(in_signal)
  50. int in_signal;
  51. {
  52.   if(in_signal == SIGTERM) 
  53.     running = 0;   /* terminate when requested by outside */
  54. }
  55.  
  56. cleanup_exit(exval)
  57. int exval;
  58. {
  59.   cmon_term();
  60.   exit(exval);
  61. }
  62.  
  63. cmon_init()
  64. {
  65.   FILE *ifd;
  66.   char buf[132];
  67.   int i, foundme;
  68.  
  69.   dopen();
  70.  
  71.   for(i=0; i<MAX_C_LCB; i++) {
  72.     c_lcb[i].port = c_lcb[i].link = c_lcb[i].cid = 0;
  73.     c_lcb[i].sname[0] = '\0';
  74.     c_lcb[i].raddr[0] = '\0';
  75.     c_lcb[i].cbuf = c_lcb[i].rbuf = NULL;
  76.   }
  77.  
  78.   for(i=0; i<MAX_C_FCB; i++) 
  79.     c_fcb[i].afifo = c_fcb[i].pid = c_fcb[i].link = 0;
  80.  
  81.   for(i=0; i<MAX_C_SCB; i++) {
  82.     c_scb[i].pid = c_scb[i].fid =
  83.       c_scb[i].lid = c_scb[i].ssid = 0;
  84.     c_scb[i].state = -1;
  85.   }
  86.  
  87.   c_lcb_cnt = 0;
  88.   foundme = 0;
  89.  
  90.   if((ifd=fopen("servers", "r")) != NULL) {
  91.     while(fgets(buf, 132, ifd)) {
  92.       if((buf[0] != '#') && (sscanf(buf, "%s %d %s",
  93.           c_lcb[c_lcb_cnt].sname,
  94.           &c_lcb[c_lcb_cnt].port,
  95.           c_lcb[c_lcb_cnt].raddr) > 0)) {
  96.         if(!foundme) {
  97.           foundme = 1;
  98.           strcpy(cname, c_lcb[c_lcb_cnt].sname);
  99.           strcpy(laddr, c_lcb[c_lcb_cnt].raddr);
  100.         } else
  101.           c_lcb_cnt++;
  102.       }
  103.     }
  104.     fclose(ifd);
  105.   } else {
  106.     strcpy(cname, "NONAMECLIENT");
  107.     strcpy(laddr, "12345");
  108.   }
  109.  
  110.   cfifo_init();
  111.   cx25_init(); 
  112. }
  113.  
  114. cmon_term()
  115. {
  116.   cfifo_term();
  117.   cx25_term();
  118.   dprintf("BFS-CMON Terminating\n");
  119.   dclose();
  120. }
  121.  
  122.  
  123. main()
  124. {
  125.   RPC_MSG rpc_msg;
  126.   int flags;
  127.  
  128.   cmon_init();
  129.  
  130.   dprintf("Basic File System - Client Monitor (BFS-CMON) Ver 1.0\n");
  131.   dprintf("Copyright (C) 1990, StonyBrook Technologies, Inc.\n");
  132.   dprintf("All Rights Reserved.\n");
  133.  
  134.   print_info();  /* print routing table to debug file */
  135.  
  136.   if(signal(SIGTERM, signal_trap) == -1) {   /* setup signal handler */
  137.     perror("SIGTERM Failed");
  138.     exit(errno);
  139.   }
  140.  
  141.   while( running ) {
  142.     if(cfifo_read(&rpc_msg, sizeof(RPC_MSG))) {
  143.       switch(rpc_msg.hdr.code) {
  144.         case RPC_FOPEN_CMD:
  145.           cmon_fopen(&rpc_msg);
  146.           break;
  147.         case RPC_FCLOSE_CMD:
  148.           cmon_fclose(&rpc_msg);
  149.           break;
  150.         case RPC_FWRITE_CMD:
  151.           cmon_fwrite(&rpc_msg);
  152.           break;
  153.         case RPC_FREAD_CMD:
  154.           cmon_fread(&rpc_msg);
  155.           break;
  156.         case RPC_FEOF_CMD:
  157.           cmon_feof(&rpc_msg);
  158.           break;
  159.         default:
  160.           break;
  161.       }
  162.     }
  163.   }
  164.  
  165.   cmon_term();
  166. }
  167.  
  168.  
  169. /* cfifo_init, _term, _open, _close, _read, _write routines */
  170.  
  171. cfifo_init()
  172. {
  173.   int flags;
  174.  
  175.   if(mknod("/tmp/CFIFO", S_IFIFO|0666, 0) == -1) return(0);
  176.  
  177.   if((cfifo=open("/tmp/CFIFO", O_RDONLY|O_NDELAY)) != -1) {
  178.     flags = fcntl(cfifo, F_GETFL, &flags);
  179.     flags &= ~O_NDELAY;
  180.     fcntl(cfifo, F_SETFL, &flags);
  181.     return(1);
  182.   } 
  183.   unlink("/tmp/CFIFO");
  184.   return(0);
  185. }
  186.  
  187. cfifo_term()
  188. {
  189.   close(cfifo);
  190.   unlink("/tmp/CFIFO");
  191. }
  192.  
  193.  
  194. cfifo_open(pid)
  195. int pid;
  196. {
  197.   int i;
  198.   for(i=0; i<MAX_C_FCB; i++)
  199.     if((c_fcb[i].link) && (c_fcb[i].pid == pid)) {
  200.       c_fcb[i].link++;
  201.       return(1);
  202.     }
  203.   for(i=0; i<MAX_C_FCB; i++)
  204.     if(!c_fcb[i].link) {
  205.       sprintf(c_fcb[i].afname, "/tmp/AFIFO.%d", pid);
  206.       if((c_fcb[i].afifo=open(c_fcb[i].afname, O_WRONLY)) != -1) {
  207.         c_fcb[i].link = 1;
  208.         c_fcb[i].pid = pid;
  209.         return(1);
  210.       } 
  211.       break;
  212.     }
  213.   return(0);
  214. }
  215.  
  216.  
  217. cfifo_close(pid)
  218. int pid;
  219. {
  220.   int i;
  221.  
  222.   for(i=0; i<MAX_C_FCB; i++)
  223.     if(c_fcb[i].pid == pid) {
  224.       c_fcb[i].link--;
  225.       if(!c_fcb[i].link) {
  226.         close(c_fcb[i].afifo);
  227.         c_fcb[i].pid = c_fcb[i].afifo = -1;
  228.       }
  229.     return(1);    
  230.     }
  231.   return(0);    
  232. }
  233.  
  234. cfifo_read(buf, cnt)
  235. char *buf;
  236. int cnt;
  237. {
  238.   return(read(cfifo, buf, cnt));
  239. }
  240.  
  241. cfifo_write(pid, buf, cnt)
  242. int pid, cnt;
  243. char *buf;
  244. {
  245.   int i;
  246.  
  247.   for(i=0; i<MAX_C_FCB; i++)
  248.     if(c_fcb[i].pid == pid)
  249.       return(write(c_fcb[i].afifo, buf, cnt));
  250.   return(0);
  251. }
  252.  
  253.  
  254. /* cx25_init, _term, _open, _close,
  255.        _send_cmd, _send_data, _recv_rsp, _recv_data */
  256.  
  257.  
  258. cx25_init()
  259. {
  260.   x25init(0); 
  261. }
  262.  
  263. cx25_term()
  264. {
  265.   x25exit(); 
  266. }
  267.  
  268. cx25_open(lid)
  269. int lid;
  270. {
  271.   if(!c_lcb[lid].link) {
  272.     dprintf("open x25 line %d\n", lid);
  273.     if(x25call(c_lcb[lid].raddr, laddr, &x25_parms,
  274.                c_lcb[lid].port, X25WAIT, &c_lcb[lid].cid) == -1) {
  275.       dprintf("x25 open error %d on line %d\n", x25error(), lid);
  276.       return(0);
  277.     }
  278.     dprintf("x25 line %d opened ok\n", lid);
  279.     c_lcb[lid].link = 1;
  280.     c_lcb[lid].cbuf = x25alloc(sizeof(RPC_FOPEN_CMD_MSG));
  281.     c_lcb[lid].rbuf = x25alloc(sizeof(RPC_FOPEN_RSP_MSG));
  282.   } else {
  283.     dprintf("link x25 line %d\n", lid);
  284.     c_lcb[lid].link++;
  285.   }
  286.   return(1);
  287. }
  288.  
  289. cx25_close(lid)
  290. int lid;
  291. {
  292.   dprintf("delink x25 line %d\n", lid);
  293.   c_lcb[lid].link--;
  294.   if(!c_lcb[lid].link) {
  295.     dprintf("close x25 line %d\n", lid);
  296.     x25free(c_lcb[lid].cbuf);
  297.     x25free(c_lcb[lid].rbuf);
  298.   }
  299.   return(1);
  300. }
  301.  
  302. cx25_send_cmd(lid, buf, cnt)
  303. int lid, cnt;
  304. char *buf;
  305. {
  306.   memcpy(c_lcb[lid].cbuf, buf, cnt);
  307.   cnt = x25send(c_lcb[lid].cid, c_lcb[lid].cbuf, cnt, 0);
  308.   return(cnt);
  309. }
  310.  
  311. cx25_send_data(lid, pid, cnt)
  312. int lid, pid, cnt;
  313. {
  314.   c_lcb[lid].dbuf = x25alloc(cnt);
  315.   cfifo_read(c_lcb[lid].dbuf, cnt);
  316.   cnt = x25send(c_lcb[lid].cid, c_lcb[lid].dbuf, cnt, 0); 
  317.   x25free(c_lcb[lid].dbuf);
  318.   return(cnt);
  319. }
  320.  
  321. cx25_recv_rsp(lid, buf, cnt)
  322. int lid, cnt;
  323. char *buf;
  324. {
  325.   cnt = x25recv(c_lcb[lid].cid, c_lcb[lid].cbuf, cnt, 0);
  326.   memcpy(buf, c_lcb[lid].cbuf, cnt);
  327.   return(cnt);
  328. }
  329.  
  330. cx25_recv_data(lid, pid, cnt)
  331. int lid, pid, cnt;
  332. {
  333.   c_lcb[lid].dbuf = x25alloc(cnt);
  334.   cnt = x25recv(c_lcb[lid].cid, c_lcb[lid].dbuf, cnt, 0); 
  335.   cfifo_write(pid, c_lcb[lid].dbuf, cnt);
  336.   x25free(c_lcb[lid].dbuf);
  337.   return(cnt);
  338. }
  339.  
  340.  
  341. /* cmon_fopen, _fclose, _fread, _fwrite, _feof routines */
  342.  
  343.  
  344. cmon_fopen(rpc_msg)
  345. RPC_MSG *rpc_msg;
  346. {
  347.   int pid, fid, lid, csid;
  348.   RPC_FOPEN_CMD_MSG focmd;
  349.   RPC_FOPEN_RSP_MSG forsp;
  350.  
  351.   cfifo_read(focmd.sname, rpc_msg->hdr.dlen);
  352.  
  353.   pid = rpc_msg->hdr.csid;
  354.   fid = rpc_msg->hdr.ssid;
  355.   lid = get_server_id(focmd.sname);
  356.  
  357.   if(cfifo_open(pid)) {
  358.     if(lid != -1 ) {
  359.       dprintf("fopen req for %s - ok\n", focmd.sname);
  360.       if(cx25_open(lid)) {
  361.         if((csid=allocate_csid(pid, fid, lid)) != -1) {
  362.           focmd.hdr.code = RPC_FOPEN_CMD;
  363.           focmd.hdr.csid = csid;
  364.           focmd.hdr.ssid = 0;
  365.           focmd.hdr.dlen = rpc_msg->hdr.dlen;
  366.           cx25_send_cmd(l